{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial: Discrete Choice with Taste Shocks\n",
    "\n",
    "1. Solve SIM model with labor force participation\n",
    "2. Practice: add search frictions\n",
    "3. Practice: explore effect of taste shock scale on block Jacobian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numba import njit\n",
    "import matplotlib.pyplot as plt\n",
    "from copy import deepcopy\n",
    "# import sequence_jacobian as sj\n",
    "\n",
    "from sequence_jacobian import grids, interpolate\n",
    "from sequence_jacobian.blocks.stage_block import StageBlock\n",
    "from sequence_jacobian.blocks.support.stages import Continuous1D, ExogenousMaker, LogitChoice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 SIM model with labor force participation\n",
    "\n",
    "So far in this course, we used `HetBlock` to represent the SIM model in SSJ. `HetBlock` supports models with a sequence of discrete shocks (given by `exogenous` kwarg in constructor) followed by a continuous choice. `StageBlock` is a more flexible version of `HetBlock`, that allows for an arbitrary sequence of stages, including logit choice from a discrete choice set. Eventually, `StageBlock` may just supersede `HetBlock`, but it's still in an experimental stage, so we did not want to get rid of our trusty `HetBlock` yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Setup\n",
    "\n",
    "Strictly-speaking, the state space in the beginning of period is $(z, a)$\n",
    "<!-- - employment status $e \\in \\{E, N\\}$ chosen by househod -->\n",
    "- productivity $z \\in \\{z_1, \\dots, z_{m}\\} \\equiv \\mathcal{G}_z$\n",
    "- liquid assets $a \\in [\\underline{a}, \\infty)$\n",
    "\n",
    "However, in stage 3, we'll want to solve for consumption and asset policies conditional on labor supply $n \\in \\{0, 1\\}.$ The implementation of `StageBlock` does not allow for changing the number of axes between stages. So, we will define everything on the largest grid we need, i.e. $(n, z, a)$ for\n",
    "- labor supply $n \\in \\{0, 1\\}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stage 1: productivity shock\n",
    "\n",
    "Labor productivity follows a discretized AR(1) process in logs\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\log z &= \\rho_z \\log z_{-} + \\epsilon\n",
    "\\\\\n",
    "\\epsilon &\\sim \\mathcal{N}(0, \\sigma_z^2)\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "As always, we're going to discretize this using Rouwenhorst method. So, we'll end up with a finite grid $\\mathcal{G_z} \\equiv [z_1, \\dots, z_m]$ and transition matrix $\\Pi_z \\in \\mathbb{R}^{m\\times m}$. Then, backward iteration amounts to\n",
    "$$\n",
    "V^{(1)} = \\Pi_z V^{(2)}\n",
    "$$\n",
    "and forward iteration amount to\n",
    "$$\n",
    "D^{(2)} = \\Pi_z' D^{(1)}\n",
    "$$\n",
    "**Exploiting sparsity**: shock is independent of all other states $(n, a)$.\n",
    "\n",
    "Let's initialize this stage using the---somewhat awkwardly named---constructor `ExogenousMaker`. The inputs of this function are\n",
    "- `markov_name`: name of Markov matrix that drives this state\n",
    "- `index`: axis of corresponding state\n",
    "- `name`: just a name for the stage (this is how we'll refer to stage-specific data later)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "prod_stage = ExogenousMaker(markov_name='z_markov', index=1, name='prod')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stage 2: Labor supply choice\n",
    "\n",
    "Households decide whether to work full time or not at all. Working has a utility cost $\\varphi.$ On the slides, I accounted for disutility of labor in the consumption-saving stage. Then, it affects this stage via next-period value function $V^{(3)}$. Alternatively, we can account for the cost here. Also, notice that \"phantom state\" $n_-$ that we need to span the third axis of the state space.\n",
    "$$\n",
    "V^{(2)}(n_{-}, z, a_-) = \\max_{n \\in \\{0, 1\\}} V^{(3)}(n, z, a_-) - \\varphi n + \\underbrace{\\varepsilon(n)}_{\\text{taste shock}}\n",
    "$$\n",
    "Solving this stage will yield us choice probabilities $P(n|n_-, z, a_-)$. This will be used in forward iteration\n",
    "$$\n",
    "D^{(3)}(n, \\bullet) = \\sum_{n_-} P(n|n_-, \\bullet)D^{(2)}(n_-, \\bullet)\n",
    "$$\n",
    "\n",
    "**Sparsity**: $P$ maps $(n_-, \\bullet)$ into $n$ and not $(n, \\bullet).$ \n",
    "\n",
    "We initialize the logit choice stage via the---aptly named---constructor `LogitChoice`. The inputs are\n",
    "- `value`: name of value function, SSJ has to know which object to apply the logsum formula to\n",
    "- `backward`: names of other variables that have to be propagated backward, typically this is partial value function needed for EGM in continuous choice stage \n",
    "- `index`: axis of correspoinding state\n",
    "- `name`: name of stage\n",
    "- `taste_shock_scale`: name of `\\sigma_\\varepsilon` parameter, needed for all formulas\n",
    "- `f`: (optional) function that implements additive utility cost on expanded state $(n| n_-, z, a_-)$. This is useful to implement costs that depend on origin as well as destination $(n|n_-)$. Setting some costs to infinity implements constraints on discrete choice (more on this below).\n",
    "\n",
    "Let's start by implementing the cost function `util_l`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def util_l(V, vphi):\n",
    "    # on (n| n_)\n",
    "    flow_u = np.array([[-vphi, -vphi],  # E|E and E|N\n",
    "                       [0    , 0]])     # N|E and N|N\n",
    "\n",
    "    # on (n| n_, z, a)\n",
    "    shape = np.zeros((2, 2,) + V.shape[1:])\n",
    "    flow_u = flow_u[..., np.newaxis, np.newaxis] + shape\n",
    "\n",
    "    return flow_u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're now ready to initialize the stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "labsup_stage = LogitChoice(value='V', backward='Va', index=0, name='labsup',\n",
    "                           taste_shock_scale='taste_shock', f=util_l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stage 3: Consumption-saving decision\n",
    "\n",
    "The Bellman equation is\n",
    "$$\n",
    "\\begin{align*}\n",
    "V_t^{(3)}(n, z, a_{-}) = \\max_{c, a} u(c) + \\beta \\mathbb{E}_tV_{t+1}^{(0)}(n, z, a)\n",
    "\\qquad\n",
    "\\text{s.t. } c + a &= (1 + r_t)a_{-} + w_t n_t z_t + T_t\n",
    "\\\\\n",
    "a &\\geq \\underline{a}\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "This is the most involved stage, as we have to implement EGM with upper envelope. To give you an idea of where we're going, we'll construct this stage with the constructor `Continuous1D`, whose inputs are almost the same as they are for a `HetBlock`:\n",
    "```\n",
    "consav_stage = Continuous1D(backward=['V', 'Va'], policy='a', f=dcegm, name='consav', hetoutputs=[labsup])\n",
    "```\n",
    "Inputs are\n",
    "- `backward`: list of variables we need to propagate backward\n",
    "- `policy`: name of endogenous state\n",
    "- `f`: function that implements single step of backward iteration, $\\left(V^{(j+1)}, V_a^{(j+1)}\\right) \\to \\left(V^{(j)}, V_a^{(j)}\\right)$\n",
    "- `hetoutputs`: (optional) list of functions reporting policies on the grid that are not required to perform the backward iteration, these functions will be called only when the backward iteration has converged\n",
    "\n",
    "Let's start building up the `dcegm` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dcegm(V, Va, a_grid, coh, y, r, beta, eis):\n",
    "    \"\"\"DC-EGM algorithm\"\"\"\n",
    "    # use all FOCs on endogenous grid\n",
    "    W = beta * V                                                  # end-of-stage vfun\n",
    "    uc_endo = beta * Va                                           # envelope condition\n",
    "    c_endo = uc_endo** (-eis)                                     # Euler equation\n",
    "    a_endo = (c_endo + a_grid - y[..., np.newaxis]) / (1 + r)     # budget constraint \n",
    "\n",
    "    # interpolate with upper envelope, enforce borrowing limit\n",
    "    V, c, a = upperenv(W, a_endo, coh, a_grid, eis)\n",
    "\n",
    "    # update Va on exogenous grid\n",
    "    uc = c ** (-1 / eis)                                          # Euler equation\n",
    "    Va = (1 + r) * uc                                             # envelope condition\n",
    "\n",
    "    return V, Va, a, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything that's new happens in `upperenv` function. This can be written in a fairly general way. First, let us use a simple wrapper to make it independent of the size of the state space. We temporarily collapse states associated with all other stages into a single axis. The real work is done by `upperenv_vec`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upperenv(W, a_endo, coh, a_grid, *args):\n",
    "    # collapse (n, z, a) into (b, a)\n",
    "    shape = W.shape\n",
    "    W = W.reshape((-1, shape[-1]))\n",
    "    a_endo = a_endo.reshape((-1, shape[-1]))\n",
    "    coh = coh.reshape((-1, shape[-1]))\n",
    "    V, c, a = upperenv_vec(W, a_endo, coh, a_grid, *args)\n",
    "\n",
    "    # report on (n, z, a)\n",
    "    return V.reshape(shape), c.reshape(shape), a.reshape(shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're finally ready to discuss the core upper envelope step. To gist is the following. We consider every segment of the endogenous grid $(a_{j}^{endo}, a_{j+1}^{endo})$ and find all the exogenous gridpoints $a^{grid}_i$ that fall into that segment. We interpolate there to get a candidate solution $a_i$. Since the endogenous grid is non-monotonic, the same point $a^{grid}_i$ may be bracketed by another segment $(a_{\\tilde j}^{endo}, a_{\\tilde j+1}^{endo}).$ When this happens, we keep the solution that gives higher value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def upperenv_vec(W, a_endo, coh, a_grid, *args):\n",
    "    \"\"\"Interpolate value function and consumption to exogenous grid.\"\"\"\n",
    "    n_b, n_a = W.shape\n",
    "    a = np.zeros_like(W)\n",
    "    c = np.zeros_like(W)\n",
    "    V = -np.inf * np.ones_like(W)\n",
    "\n",
    "    # loop over other states, collapsed into single axis\n",
    "    for ib in range(n_b):\n",
    "        # loop over segments of endogenous asset grid from EGM (not necessarily increasing)\n",
    "        for ja in range(n_a - 1):\n",
    "            a_low, a_high = a_endo[ib, ja], a_endo[ib, ja + 1]\n",
    "            W_low, W_high = W[ib, ja], W[ib, ja + 1]\n",
    "            ap_low, ap_high = a_grid[ja], a_grid[ja + 1]\n",
    "            \n",
    "           # loop over exogenous asset grid (increasing) \n",
    "            for ia in range(n_a):  \n",
    "                acur = a_grid[ia]\n",
    "                coh_cur = coh[ib, ia]\n",
    "                \n",
    "                interp = (a_low <= acur <= a_high) \n",
    "                extrap = (ja == n_a - 2) and (acur > a_endo[ib, n_a - 1])\n",
    "\n",
    "                # exploit that a_grid is increasing\n",
    "                if (a_high < acur < a_endo[ib, n_a - 1]):\n",
    "                    break\n",
    "\n",
    "                if interp or extrap:\n",
    "                    W0 = interpolate.interpolate_point(acur, a_low, a_high, W_low, W_high)\n",
    "                    a0 = interpolate.interpolate_point(acur, a_low, a_high, ap_low, ap_high)\n",
    "                    c0 = coh_cur - a0\n",
    "                    V0 = util_c(c0, *args) + W0\n",
    "\n",
    "                    # upper envelope, update if new is better\n",
    "                    if V0 > V[ib, ia]:\n",
    "                        a[ib, ia] = a0 \n",
    "                        c[ib, ia] = c0\n",
    "                        V[ib, ia] = V0\n",
    "\n",
    "        # Enforce borrowing constraint\n",
    "        ia = 0\n",
    "        while ia < n_a and a_grid[ia] <= a_endo[ib, 0]:\n",
    "            a[ib, ia] = a_grid[0]\n",
    "            c[ib, ia] = coh[ib, ia]\n",
    "            V[ib, ia] = util_c(c[ib, ia], *args) + W[ib, 0]\n",
    "            ia += 1\n",
    "\n",
    "    return V, c, a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `upperenv_vec` has to evaluate flow utility from consumption at interpolated points. Let's define `util_c` function that's njitted because it's called within an njitted function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def util_c(c, eis):\n",
    "    if eis == 1:\n",
    "        u = np.log(c)\n",
    "    else:\n",
    "        u = c ** (1 - 1 / eis) / (1 - 1 / eis)\n",
    "    return u\n",
    "\n",
    "\n",
    "def employment(c):\n",
    "    l = np.zeros_like(c)\n",
    "    l[0, ...] = 1\n",
    "    return l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, let's report the mass of households that choose to work in a given period. This could be read off from the choice probabilities but it's more convenient to define it directly as a `hetoutput`, attached to the consav stage.  \n",
    "\n",
    "Now, we have all the pieces to construct the consumption-savings stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "consav_stage = Continuous1D(backward=['V', 'Va'], policy='a', f=dcegm,\n",
    "                            name='consav', hetoutputs=[employment])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Put everything together\n",
    "\n",
    "Let's stitch together the 3 stages to form the `StageBlock` representing this HA problem. As in the case of a `HetBlock`, we need also have to add \n",
    "- `backward_init`: function that constructs the initial guess for backward variables\n",
    "- `hetinputs`: (optional) list of functions that map aggregate inputs from outside the block into multidimensional inputs\n",
    "\n",
    "As usual, we compute the initial guess from an old Keynesian consumption function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hh_init(coh, a_grid, eis):\n",
    "    V = util_c(0.2 * coh, eis) / 0.01\n",
    "    Va = np.empty_like(V)\n",
    "    Va[..., 1:-1] = (V[..., 2:] - V[..., :-2]) / (a_grid[2:] - a_grid[:-2])\n",
    "    Va[..., 0] = (V[..., 1] - V[..., 0]) / (a_grid[1] - a_grid[0])\n",
    "    Va[..., -1] = (V[..., -1] - V[..., -2]) / (a_grid[-1] - a_grid[-2])\n",
    "    return V, Va "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's specify hetinputs.\n",
    "- `make_grids`: construct Markov process for productivity and the assets grid \n",
    "- `labor_income`: combines grids with aggregate wage and interest rate to build income and cash on hand\n",
    "\n",
    "**Comment:** Matt advocated for double exponential grid for assets in SIM model. Here, I don't want to bunch points as much near the borrowing constraint, because discrete choice nonlinearities away from the borrowing constraint as well. Our old `grids.agrid` function does single-exponential grid, which I will use here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_grids(rho_z, sd_z, n_z, min_a, max_a, n_a):\n",
    "    z_grid, z_dist, z_markov = grids.markov_rouwenhorst(rho_z, sd_z, n_z)\n",
    "    a_grid = grids.agrid(max_a, n_a, min_a)\n",
    "    return z_grid, z_dist, z_markov, a_grid\n",
    "\n",
    "\n",
    "def labor_income(a_grid, z_grid, r, w):\n",
    "    y = z_grid[np.newaxis, :] * np.array([w, 0.1])[:, np.newaxis]           # on (n, z)\n",
    "    coh = (1 + r) * a_grid[np.newaxis, np.newaxis, :] + y[..., np.newaxis]  # on (n, z, a)\n",
    "    return y, coh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At last, we assemble the `StageBlock`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<StageBlock 'hh' with stages ['prod', 'labsup', 'consav']>\n",
      "Inputs: ['taste_shock', 'vphi', 'r', 'beta', 'eis', 'rho_z', 'sd_z', 'n_z', 'min_a', 'max_a', 'n_a', 'w']\n",
      "Outputs: ['A', 'C', 'L']\n"
     ]
    }
   ],
   "source": [
    "hh = StageBlock([prod_stage, labsup_stage, consav_stage], name='hh',\n",
    "                backward_init=hh_init, hetinputs=[make_grids, labor_income])\n",
    "\n",
    "print(hh)\n",
    "print(f\"Inputs: {hh.inputs}\")\n",
    "print(f\"Outputs: {hh.outputs}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Solving the baseline model\n",
    "\n",
    "Consider 3 cases.\n",
    "- `sim`: no disutility from labor implies that everybody works all the time\n",
    "- `ck`: disutility of labor binds for non-negligible share of population, scale of taste shock is tiny\n",
    "- `ck_smooth`: same as `ck` but taste shocks are larger\n",
    "\n",
    "Let's start by specifying the calibration dictionary for each case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "cali = dict()\n",
    "\n",
    "cali['sim'] = {'taste_shock': 1E-5, 'vphi': 0.0, 'r': 0.02/4, 'beta': 0.97, 'eis': 0.5,\n",
    "               'rho_z': 0.95, 'sd_z': 0.5, 'n_z': 7,\n",
    "               'min_a': 0.0, 'max_a': 200, 'n_a': 200, 'w': 1.0}\n",
    "\n",
    "cali['ck'] = deepcopy(cali['sim'])\n",
    "cali['ck']['vphi'] = 1.0\n",
    "\n",
    "cali['ck_smooth'] = deepcopy(cali['ck'])\n",
    "cali['ck_smooth']['taste_shock'] = 1E-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`StageBlock` is a subclass of `Block`. As such, it has all the standard methods:\n",
    "- `steady_state` and `solve_steady_state`\n",
    "- `impulse_linear` and `solve_impulse_linear`\n",
    "- `impulse_nonlinear` and `solve_impulse_nonlinear`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aggregate employment in model sim: 1.00\n",
      "Aggregate employment in model ck: 0.85\n",
      "Aggregate employment in model ck_smooth: 0.85\n"
     ]
    }
   ],
   "source": [
    "ss = dict()\n",
    "for i in cali.keys():\n",
    "    ss[i] = hh.steady_state(cali[i])\n",
    "    print(f\"Aggregate employment in model {i}: {ss[i]['L']:0.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's in the output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<SteadyStateDict: ['A', 'C', 'L', 'taste_shock', 'vphi', 'r', 'beta', 'eis', 'rho_z', 'sd_z', 'n_z', 'min_a', 'max_a', 'n_a', 'w'], internals=['hh']>\n",
      "\n",
      "Internals of `hh` block:\n",
      "------------------------\n",
      "['taste_shock', 'vphi', 'r', 'beta', 'eis', 'rho_z', 'sd_z', 'n_z', 'min_a', 'max_a', 'n_a', 'w', 'z_grid', 'z_dist', 'z_markov', 'a_grid', 'y', 'coh', 'prod', 'labsup', 'consav']\n",
      "\n",
      "Internals of `hh` block `prod` stage:\n",
      "-------------------------------------\n",
      "['Va', 'V', 'law_of_motion', 'D']\n"
     ]
    }
   ],
   "source": [
    "print(ss['ck_smooth'])\n",
    "print(\"\")\n",
    "print(\"Internals of `hh` block:\")\n",
    "print(\"------------------------\")\n",
    "print(list(ss['ck_smooth'].internals['hh'].keys()))\n",
    "print(\"\")\n",
    "print(\"Internals of `hh` block `prod` stage:\")\n",
    "print(\"-------------------------------------\")\n",
    "print(list(ss['ck_smooth'].internals['hh']['prod'].keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`law_of_motion` is the abstract class that represents Markov matrices $\\Lambda \\in \\mathbb{R}^{N \\times N}$ on the slides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`prod` stage's law of motion represented by a small n_z*n_z matrix:\n",
      "-------------------------------------------------------------------\n",
      "Pi_z of size (7, 7)\n",
      "\n",
      "`labsup` stage's law of motion represented by optimal choice probabilities:\n",
      "---------------------------------------------------------------------------\n",
      "P of size (2, 2, 7, 200)\n",
      "\n",
      "`consav` stage's law of motion represented by interpolated asset policy rule:\n",
      "-----------------------------------------------------------------------------\n",
      "(a_i, a_pi) of size (14, 200) each\n"
     ]
    }
   ],
   "source": [
    "print(\"`prod` stage's law of motion represented by a small n_z*n_z matrix:\")\n",
    "print(\"-------------------------------------------------------------------\")\n",
    "print(f\"Pi_z of size {ss['ck_smooth'].internals['hh']['prod']['law_of_motion'].Pi.shape}\")\n",
    "print(\"\")\n",
    "print(\"`labsup` stage's law of motion represented by optimal choice probabilities:\")\n",
    "print(\"---------------------------------------------------------------------------\")\n",
    "print(f\"P of size {ss['ck_smooth'].internals['hh']['labsup']['law_of_motion'].P.shape}\")\n",
    "print(\"\")\n",
    "print(\"`consav` stage's law of motion represented by interpolated asset policy rule:\")\n",
    "print(\"-----------------------------------------------------------------------------\")\n",
    "print(f\"(a_i, a_pi) of size {ss['ck_smooth'].internals['hh']['consav']['law_of_motion'].i.shape} each\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that **all** of these representation are sparse vis-a-vis $\\mathbb{R}^{N \\times N}$ for $N = 2 \\times 7 \\times 200$. The key is that instead of using some generic sparse matrix library, we wrote these subclasses specifically for the underlying stage. In sum, stages are key to exploit sparsity to the limit. And stages only make sense in discrete time. Again, this is not saying that continuous time does not have tangible advantages. But sparsity is definitely not one of them.\n",
    "\n",
    "Let's visualize policy functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fig1(ss, amax=150, amin=0, iz=3, figsize=0.6):\n",
    "    a_grid = ss['sim'].internals['hh']['a_grid']\n",
    "    a, da, c, P, V = dict(), dict(), dict(), dict(), dict()\n",
    "    models = ['sim', 'ck', 'ck_smooth']\n",
    "    for i in models:\n",
    "        a[i] = ss[i].internals['hh']['consav']['a']\n",
    "        da[i] = a[i] - a_grid\n",
    "        c[i] = ss[i].internals['hh']['consav']['c']\n",
    "        P[i] = ss[i].internals['hh']['labsup']['law_of_motion'].P\n",
    "        V[i] = ss[i].internals['hh']['labsup']['V']\n",
    "\n",
    "    fig, axes = plt.subplots(1, 3, figsize=(12*figsize, 4*figsize))\n",
    "    ax = axes.flatten()\n",
    "    \n",
    "    labels = [r'SIM', r'costly labor', r'w taste shock'] \n",
    "\n",
    "    for i, l in zip(models, labels):\n",
    "        ax[0].plot(a_grid[:amax], np.sum(P[i][:, 0, iz, :amax] * a[i][:, iz, :amax], axis=0), label=l, linewidth=2)\n",
    "    ax[0].plot(a_grid[:amax], a_grid[:amax], color='gray', linestyle=':')\n",
    "    ax[0].legend(frameon=False)\n",
    "    ax[0].axhline(0, color='gray', linestyle=':')\n",
    "    ax[0].set_title('Assets')\n",
    "\n",
    "    for i, l in zip(models, labels):\n",
    "        ax[1].plot(a_grid[:amax], np.sum(P[i][:, 0, iz, :amax] * c[i][:, iz, :amax], axis=0), label=l, linewidth=2)\n",
    "    ax[1].set_title('Consumption')\n",
    "\n",
    "    for i, l in zip(models, labels):\n",
    "        ax[2].plot(a_grid[amin:amax], P[i][0, 0, iz, amin:amax], label=l, linewidth=2)\n",
    "    ax[2].set_title('Labor supply (probability)')\n",
    "    \n",
    "    for k in ax:\n",
    "        k.set_xlabel('assets')\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 960x320 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig1(ss, amax=85, iz=3, figsize=0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Adding search frictions\n",
    "\n",
    "Let's tweak this model by adding search frictions. Let's assume that assume that households can choose employment only if they have an ongoing employment relationship (they were employed last period and have not lost their job) or have received a job offer (they were unemployed last period, and got an offer).\n",
    "\n",
    "How to do this? All we have to do is introducing a new discrete shock stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "search_stage = ExogenousMaker(markov_name='e_markov', index=0, name='search')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a hetinput function that builds the transition matrix for employment shocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labor_lom(f, s):\n",
    "    e_markov = np.array([[1 - s, s], [f, 1 - f]])\n",
    "    return e_markov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have to modify to `labsup` stage to implements constraints on labor supply. We can implement this by saying that flow utility from choosing $n=1$ conditional on $n_{-} = 0$ is negtive infinity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def util_l_search(V, vphi):\n",
    "    # on (n| n)\n",
    "    flow_u = np.array([[-vphi, -np.inf],  # E|E and E|N\n",
    "                       [0, 0]])           # N|E and N|N\n",
    "\n",
    "    # on (n| n, z, a) grid\n",
    "    shape = np.zeros((2, 2,) + V.shape[1:])\n",
    "    flow_u = flow_u[..., np.newaxis, np.newaxis] + shape\n",
    "\n",
    "    return flow_u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're now ready to initialize the stage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "labsup_search_stage = LogitChoice(value='V', backward='Va', index=0, name='labsup_search',\n",
    "                                  taste_shock_scale='taste_shock', f=util_l_search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build `StageBlock`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<StageBlock 'hh2' with stages ['prod', 'search', 'labsup_search', 'consav']>\n",
      "Inputs: ['taste_shock', 'vphi', 'r', 'beta', 'eis', 'rho_z', 'sd_z', 'n_z', 'min_a', 'max_a', 'n_a', 'w', 'f', 's']\n",
      "Outputs: ['A', 'C', 'L']\n"
     ]
    }
   ],
   "source": [
    "hh2 = StageBlock([prod_stage, search_stage, labsup_search_stage, consav_stage], name='hh2',\n",
    "                backward_init=hh_init, hetinputs=[make_grids, labor_income, labor_lom])\n",
    "\n",
    "print(hh2)\n",
    "print(f\"Inputs: {hh2.inputs}\")\n",
    "print(f\"Outputs: {hh2.outputs}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Include job-finding and separation rates in calibration dicts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in cali.keys():\n",
    "    cali[i]['f'] = 0.6\n",
    "    cali[i]['s'] = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in cali.keys():\n",
    "    ss[i + '_search'] = hh2.steady_state(cali[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot labor supply functions only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fig2(ss, amax=150, iz=3, figsize=0.6):\n",
    "    a_grid = ss['sim_search'].internals['hh2']['a_grid']\n",
    "    P1 = ss['ck'].internals['hh']['labsup']['law_of_motion'].P\n",
    "    P2 = ss['ck_search'].internals['hh2']['labsup_search']['law_of_motion'].P\n",
    "\n",
    "    plt.plot(a_grid[:amax], P1[0, 0, iz, :amax], label='frictionless', linewidth=2)\n",
    "    plt.plot(a_grid[:amax], P2[0, 0, iz, :amax], label='search friction', linewidth=2)\n",
    "    plt.legend(frameon=False)\n",
    "    plt.axhline(0, color='gray', linestyle=':')\n",
    "    plt.title('Labor supply')\n",
    "    plt.xlabel('assets')\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having a job is much more valuable in a world with search frictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig2(ss, 110)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jacobians\n",
    "\n",
    "Disregard this warning. It's triggered by differentiating the discrete choice stage with `-np.inf` in flow utility. We'll turn of this warning in a future patch to the toolkit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/johanneswieland/Dropbox/MPC/Tasks/venv/lib/python3.9/site-packages/sequence_jacobian/utilities/function.py:118: RuntimeWarning: invalid value encountered in subtract\n"
     ]
    }
   ],
   "source": [
    "J = dict()\n",
    "for i in ['sim', 'ck', 'ck_smooth']:\n",
    "    J[i] = hh.jacobian(ss[i], ['r', 'w'], T=50)\n",
    "    J[i + '_search'] = hh2.jacobian(ss[i  + '_search'], ['f', 's', 'r', 'w'], T=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Search frictions significantly reduce intertemporal substitution in labor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(J['ck_smooth']['L']['w'][:20, 8], label='frictionless')\n",
    "plt.plot(J['ck_smooth_search']['L']['w'][:20, 8], label='w friction')\n",
    "plt.axhline(0, color='gray', linestyle=':')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('venv': venv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "667cbca6dc8f50ab1e9f54e227227bc682df229d6a800546a66430cfa8ca1ea8"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
